{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:32:19.455566Z",
     "start_time": "2025-01-17T02:32:19.450543Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:32:19.540144Z",
     "start_time": "2025-01-17T02:32:19.507290Z"
    }
   },
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分\n",
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "outputs": [],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:32:22.296468Z",
     "start_time": "2025-01-17T02:32:19.541152Z"
    }
   },
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205])\n",
    ")\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2860]), tensor([0.3205]))\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型\n",
    "\n",
    "这里我们没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，我们这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。感兴趣的同学可以自己动手修改并比对效果。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:32:22.304974Z",
     "start_time": "2025-01-17T02:32:22.296468Z"
    }
   },
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=2):\n",
    "        super().__init__()\n",
    "        self.transforms = transforms\n",
    "        self.flatten = nn.Flatten()\n",
    "        # 多加几层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),  # in_features=784, out_features=300\n",
    "            nn.SELU(),\n",
    "        )\n",
    "        # 加19层\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"selu\", nn.SELU()) # 这里采用SELU激活函数,前面的名字可以自己定义\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "        \n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        x = self.transforms(x)\n",
    "        x = self.flatten(x)  \n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear_00\tparamerters num: 78400\n",
      "Linear_00\tparamerters num: 100\n",
      "Linear_01\tparamerters num: 10000\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_02\tparamerters num: 10000\n",
      "Linear_02\tparamerters num: 100\n",
      "Linear_03\tparamerters num: 10000\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_04\tparamerters num: 10000\n",
      "Linear_04\tparamerters num: 100\n",
      "Linear_05\tparamerters num: 10000\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_06\tparamerters num: 10000\n",
      "Linear_06\tparamerters num: 100\n",
      "Linear_07\tparamerters num: 10000\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_08\tparamerters num: 10000\n",
      "Linear_08\tparamerters num: 100\n",
      "Linear_09\tparamerters num: 10000\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_10\tparamerters num: 10000\n",
      "Linear_10\tparamerters num: 100\n",
      "Linear_11\tparamerters num: 10000\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_12\tparamerters num: 10000\n",
      "Linear_12\tparamerters num: 100\n",
      "Linear_13\tparamerters num: 10000\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_14\tparamerters num: 10000\n",
      "Linear_14\tparamerters num: 100\n",
      "Linear_15\tparamerters num: 10000\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_16\tparamerters num: 10000\n",
      "Linear_16\tparamerters num: 100\n",
      "Linear_17\tparamerters num: 10000\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_18\tparamerters num: 10000\n",
      "Linear_18\tparamerters num: 100\n",
      "Linear_19\tparamerters num: 10000\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_20\tparamerters num: 1000\n",
      "Linear_20\tparamerters num: 10\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:32:22.308348Z",
     "start_time": "2025-01-17T02:32:22.304974Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "outputs": [],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:32:22.313015Z",
     "start_time": "2025-01-17T02:32:22.308348Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "outputs": [],
   "execution_count": 17
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:32:22.316641Z",
     "start_time": "2025-01-17T02:32:22.313015Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 18
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:32:22.319719Z",
     "start_time": "2025-01-17T02:32:22.316641Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 19
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:42:01.375878Z",
     "start_time": "2025-01-17T02:32:22.319719Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                    \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/selu\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints/selu\"):\n",
    "    #创建多级目录\n",
    "    os.makedirs(\"checkpoints/selu\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/selu\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.001)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    "    )"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "0dc8578f801a4b8e9bf9e962d832d103"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 32 / global_step 120000\n"
     ]
    }
   ],
   "execution_count": 20
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:42:01.525386Z",
     "start_time": "2025-01-17T02:42:01.375878Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(6 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10000)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 21
  },
  {
   "cell_type": "markdown",
   "source": [
    "## selu激活函数，可以加速收敛，效果相对于relu更好"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:42:02.602428Z",
     "start_time": "2025-01-17T02:42:01.525907Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/selu/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\41507\\AppData\\Local\\Temp\\ipykernel_30888\\33674140.py:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  model.load_state_dict(torch.load(\"checkpoints/selu/best.ckpt\", map_location=\"cpu\"))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3380\n",
      "accuracy: 0.8846\n"
     ]
    }
   ],
   "execution_count": 22
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
